home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 010a / dietdisc.zip / SLIM.C < prev    next >
C/C++ Source or Header  |  1991-02-10  |  11KB  |  450 lines
  1.  
  2.  
  3. #define  BUFSIZE 32000
  4. #define  NUMPTRS   250
  5. #define  MAXFILES  400
  6. #define  TRIES      16
  7. #define  DELAY       2
  8. #define  TRUE        1
  9. #define  FALSE       0
  10.  
  11. #include <stdio.h>
  12. #include <dos.h>
  13. #include <io.h>
  14. #include <string.h>
  15. #include <fcntl.h>
  16. #include <dir.h>
  17. #include <process.h>
  18. #include <stdlib.h>
  19. #include <alloc.h>
  20. #include <mem.h>
  21.  
  22. extern  unsigned char   _osmajor;
  23.  
  24. void    skinny_file(char *);
  25. void    getbuffer(void);
  26. char    *filefind(void);
  27. int     int24handler(int, int, int, int);
  28. int     isnet(void);
  29.  
  30. /***************************************************************/
  31.  
  32. int     fhin, fhout;
  33. char    *buffer;
  34. int     bytecount;
  35. int     buffcount;
  36.  
  37. double  oldsize, newsize;
  38. double  skinny_pct;
  39.  
  40. char    *filename_ptr;
  41. char    msg[25];
  42. char    *footprint;
  43. char    foottest[80];
  44.  
  45. char    *filepattern;
  46. struct  ffblk   dos_find_blk;
  47.  
  48. char    drive[MAXDRIVE];
  49. char    dirs[MAXDIR];
  50. char    filename[MAXFILE];
  51. char    ext[MAXEXT];
  52. int     name_flag;
  53.  
  54. char    *filename_array;
  55. char    *name_ptrs[MAXFILES];
  56.  
  57. int     count, error, mode, fileattrib, driveno;
  58. int     network, exists;
  59. int     numfiles;
  60. int     firsttime;
  61. int     i, j, k;
  62. int     argcx, argdx;
  63. long    filetime;
  64.  
  65. char far    *mydta;
  66. char far    *olddta;
  67. unsigned    useg;
  68. unsigned    int our_cs;
  69.  
  70. char    iptr[MAXPATH];
  71. char    optr[MAXPATH];
  72. char    *ctrlinfo = "lZdIeT\0\0\0\0\0\0\0\0\0\0";
  73. struct  ftime ftimestruc;
  74. char    fullname[MAXPATH];
  75. char    temp_ext[MAXEXT];
  76. int     temp_flag, exe_flag;
  77.  
  78. /***************************************************************/
  79.  
  80. void    main (argc, argv, envp)
  81.                 int     argc;
  82.                 char    *argv[];
  83.                 char    *envp[];
  84.  
  85.         {
  86.         harderr(int24handler);
  87.  
  88.         count = 0;
  89.         exe_flag = 0;
  90.  
  91.         _AX = 0x3341;
  92.         geninterrupt(0x21);
  93.         if (_DX == 0x1234)
  94.             goto loaded_ok;
  95.  
  96.         printf("\n\nPlease run Diet Disk before trying to slim files.\n\n");
  97.         exit(1);
  98.  
  99.  
  100. loaded_ok:
  101.         if ( (argc != 2) && (argc != 3) )
  102.            {
  103.            printf("\n\nUsage: SLIM <filename>.  Wildcards are * and ?.\n\n");
  104.            exit(0);
  105.            }
  106.  
  107.         if (argc == 3)
  108.             {
  109.             strupr(argv[2]);
  110.             if (strcmp(argv[2], "/E") == 0)
  111.                 {
  112.                 exe_flag = 1;
  113.                 goto parse_argv;
  114.                 }
  115.             else
  116.                 {
  117.            printf("\n\nUsage: SLIM <filename>.  Wildcards are * and ?.\n\n");
  118.            exit(0);
  119.                 }
  120.             }
  121.  
  122.  
  123. parse_argv:
  124.         name_flag = fnsplit(argv[1], drive, dirs, filename, ext);
  125.         filepattern = argv[1];
  126.  
  127.  
  128.         if (_osmajor < 2)
  129.            {
  130.            printf("\n\nIncorrect DOS version.\n\n");
  131.            goto bail_out;
  132.            }
  133.  
  134.         if ((buffer = (char *) malloc(BUFSIZE)) == NULL)
  135.            {
  136.            printf("\n\nInsufficient memory.\n\n");
  137.            goto bail_out;
  138.            }
  139.  
  140.         if ((filename_array = (char *) calloc(MAXFILES, 14)) == NULL)
  141.            {
  142.            printf("\n\nInsufficient memory.\n\n");
  143.            goto bail_out;
  144.            }
  145.  
  146.  
  147.         if ((mydta = (char *) malloc(128)) == NULL)
  148.            {
  149.            printf("\n\nInsufficient memory.\n\n");
  150.            goto bail_out;
  151.            }
  152.  
  153.  
  154.         _fmode  = O_BINARY;
  155.         error   = 0;
  156.         mode    = O_RDONLY;
  157.         network = 0;
  158.  
  159.         if (isnet())
  160.            {
  161.            network = 1;
  162.            mode    = O_RDONLY | O_DENYNONE;
  163.            argdx   = TRIES;
  164.            argcx   = DELAY;
  165.            ioctl (0, 11, argdx, argcx);
  166.            }
  167.  
  168.  
  169.         numfiles = 0;
  170.         bytecount = 0;
  171.  
  172.         while ( (filename_ptr = filefind()) != NULL)
  173.             {
  174.             name_ptrs[numfiles] = filename_array + bytecount;
  175.             movmem(filename_ptr,  filename_array + bytecount,
  176.                         strlen(filename_ptr)+1);
  177.             bytecount += (strlen(filename_ptr)+1);
  178.             numfiles++;
  179.             if (numfiles > (MAXFILES - 5))
  180.                 {
  181.                 printf("\nToo many files (max is 400).\n");
  182.                 printf("Change your wildcards to slim fewer files at a time.\n");
  183.                 goto bail_out;
  184.                 }
  185.             }
  186.  
  187.         if (numfiles == 0)
  188.            {
  189.            printf("\nFile(s) not found.\n");
  190.            goto bail_out;
  191.            }
  192.  
  193.         printf("Slimming files....\n\n");
  194.  
  195.         for (i = 0; i < numfiles; i++)
  196.             skinny_file(name_ptrs[i]);
  197.         
  198.  
  199. normal_exit:
  200.         printf("\n%d file(s) slimmed.\n", count);
  201.  
  202.         if (error)
  203.             {
  204.             printf("Slim ended.  Some errors occurred.\n");
  205.             exit(1);
  206.             }
  207.  
  208.         printf("\n\nSlim ended successfully.\n");
  209.         exit(0);
  210.  
  211.  
  212. bail_out:
  213.         fcloseall();
  214.         printf("\n%d file(s) slimmed.\n", count);
  215.         printf("Slim ended due to error.\n");
  216.         exit(1);
  217.         }
  218.  
  219. /***************************************************************/
  220.  
  221. void    skinny_file(char *cptr)
  222.         {
  223.         strcpy (iptr, cptr);
  224.         strupr(iptr);
  225.         printf("  %-14s ", iptr);
  226.  
  227.         temp_flag = fnsplit(iptr, NULL, NULL, NULL, temp_ext);
  228.  
  229.         if (strcmp(".COM", temp_ext) == 0)
  230.            {
  231.            printf("\n.COM files cannot be slimmed!\n");
  232.            error = 1;
  233.            return;
  234.            }
  235.  
  236.         if (strcmp(".EXE", temp_ext) == 0)
  237.             if (exe_flag == 0)
  238.                {
  239.                printf("\n.EXE files cannot be slimmed!\n");
  240.                error = 1;
  241.                return;
  242.                }
  243.  
  244.         fnmerge(fullname, drive, dirs, iptr, NULL);
  245.         strcpy(iptr, fullname);
  246.         fnmerge(optr, drive, dirs, "TEMP", ".FAT");
  247.  
  248.         if (strstr("FATTEN.FIL", iptr) != NULL)
  249.            {
  250.            printf("\nInvalid file name!\n");
  251.            error = 1;
  252.            return;
  253.            }
  254.  
  255.         if (strstr(optr, iptr) != NULL)
  256.            {
  257.            printf("\nInvalid file name!\n");
  258.            error = 1;
  259.            return;
  260.            }
  261.  
  262.         if ((fhin = _open(iptr, mode)) == -1)
  263.            {
  264.            printf("\nInternal error; file not found.\n");
  265.            exit(1);
  266.            }
  267.  
  268.         findfirst(iptr, (struct ffblk *) &dos_find_blk, 0);
  269.         oldsize  = (double) dos_find_blk.ff_fsize;
  270.         newsize  = (double) filelength(fhin);
  271.  
  272.         if (oldsize != newsize)
  273.             {
  274.             _close(fhin);
  275.             printf("....is already slim.\n");
  276.             return;
  277.             }
  278.  
  279.         if ((fhout = _creat(optr, 0)) == -1)
  280.            {
  281.            printf("\nInternal error--file creation.\n");
  282.            exit(1);
  283.            }
  284.  
  285.         memcpy (&buffer[0], ctrlinfo, 16);
  286.  
  287.         if ((_write(fhout, buffer, 16)) != 16)
  288.            {
  289.            printf("\nError writing file.");
  290.            printf("\nSlim operation terminated.\n");
  291.            exit(1);
  292.            }
  293.  
  294.         setmem (&buffer[ 0], 16,        (char)   0);
  295.         setmem (&buffer[16], NUMPTRS*6, (char) 255);
  296.  
  297.         if ((_write(fhout, buffer, (NUMPTRS*6)+16)) != (NUMPTRS*6)+16)
  298.            {
  299.            printf("\nError writing file.");
  300.            printf("\nSlim operation terminated.\n");
  301.            exit(1);
  302.            }
  303.  
  304.         _close(fhout);
  305.  
  306.         if ((fhout = _open(optr, O_RDWR)) == -1)
  307.            {
  308.            printf("\nInternal error; re-open failed.\n");
  309.            exit(1);
  310.            }
  311.  
  312.         getbuffer();
  313.  
  314.         while (buffcount > 0)
  315.               {
  316.               if ((_write(fhout, buffer, buffcount)) != buffcount)
  317.                  {
  318.                  printf("\nError writing file.");
  319.                  printf("\nSlim operation terminated.\n");
  320.                  remove (optr);
  321.                  exit(1);
  322.                  }
  323.  
  324.               if (buffcount < BUFSIZE)
  325.                  break;
  326.  
  327.               getbuffer();
  328.               }
  329.  
  330.         getftime(fhin, &ftimestruc);
  331.         setftime(fhout,&ftimestruc);
  332.  
  333.         _close (fhin);
  334.         _close (fhout);
  335.  
  336.         findfirst(iptr, (struct ffblk *) &dos_find_blk, 0);
  337.         oldsize   = dos_find_blk.ff_fsize * 1.0;
  338.  
  339.         findfirst(optr, (struct ffblk *) &dos_find_blk, 0);
  340.         newsize   = dos_find_blk.ff_fsize * 1.0;
  341.  
  342.         if (oldsize == 0.0)
  343.            skinny_pct = 0.0;
  344.         else
  345.            skinny_pct = ((oldsize - newsize) / oldsize) * 100.0;
  346.  
  347.         if (skinny_pct < +10.0)
  348.             {
  349.             remove (optr);
  350.             printf("....is too small to benefit from slimming.\n");
  351.             return;
  352.             }
  353.  
  354.         printf ("old size = %10.0lf  new size = %10.0lf  ", oldsize, newsize);
  355.         printf(" (% 4.0lf%%)\n", skinny_pct);
  356.  
  357.         remove (iptr);
  358.         rename (optr, iptr);
  359.         count++;
  360.  
  361.         }
  362.  
  363. /***************************************************************/
  364.  
  365. void    getbuffer()
  366.         {
  367.         if ((buffcount = _read(fhin, buffer, BUFSIZE)) == -1)
  368.            {
  369.            printf("\nError reading file.");
  370.            printf("\nSlim operation terminated.\n");
  371.            exit(1);
  372.            }
  373.         }
  374.  
  375. /***************************************************************/
  376.  
  377. char    *filefind()
  378.         {
  379.  
  380.         olddta = getdta();
  381.  
  382.         if (firsttime) goto getnextblk;
  383.  
  384.         firsttime = 1;
  385.         if (findfirst(filepattern, (struct ffblk *) &dos_find_blk, 0) != 0)
  386.            {
  387.             setdta( (char far *) &olddta);
  388.             return(NULL);
  389.            }
  390.  
  391.         setdta( (char far *) &olddta);
  392.         return(dos_find_blk.ff_name);
  393.  
  394. getnextblk:
  395.         if (findnext( (struct ffblk *) &dos_find_blk) != 0)
  396.            {
  397.             setdta( (char far *) &olddta);
  398.             return(NULL);
  399.            }
  400.  
  401.         setdta( (char far *) &olddta);
  402.         return(dos_find_blk.ff_name);
  403.  
  404.         }
  405.  
  406. /***************************************************************/
  407.  
  408. int     isnet()
  409.  
  410.         {
  411.         union REGS      regs;
  412.  
  413.         if (_osmajor > 2 && _osminor > 0)
  414.             for (i=3; i<21; i++)
  415.                 {
  416.                 regs.x.ax = 0x4409;
  417.                 regs.x.bx = i;
  418.                 int86(0x21, ®s, ®s);
  419.                 if ( (regs.x.dx & 0x1000) == 0x1000 )
  420.                     return(TRUE);
  421.                 }
  422.         return(FALSE);
  423.         }
  424.  
  425. /***************************************************************/
  426.  
  427. int     int24handler(int errval, int ax, int bp, int si)
  428.  
  429.         {
  430.         char    msg[25];
  431.         int     drive;
  432.  
  433.         if (ax < 0)
  434.             {
  435.             bdosptr(0x09, "\nDevice I/O error has occurred.\n$", 0);
  436.             bdosptr(0x09, "Attempting to recover....\n$", 0);
  437.             hardretn(-1);
  438.             }
  439.  
  440.         drive = (ax & 0x00FF);
  441.         sprintf(msg, "I/O error on disk drive %c. \n$", 'A' + drive);
  442.         bdosptr(0x09, msg, 0);
  443.         bdosptr(0x09, "Attempting to recover....\n$", 0);
  444.         hardretn(-1);
  445.         }
  446.  
  447. /***************************************************************/
  448.  
  449.  
  450.